
package sort;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.concurrent.ThreadLocalRandom;

    /**
     * 排序的辅助类
     * 生成测试数组以及对排序算法进行测试
     * @author zerorain
     * @date 2022/03/21 20:23
     **/
    public class SortHelper {
        // 获取随机数的对象
        private static final ThreadLocalRandom random = ThreadLocalRandom.current();

        /**
         * 在[left...right]上生成n个随机数
         * @param n
         * @param left
         * @param right
         * @return
         */
        public static int[] generateRandomArray(int n,int left,int right) {
            int[] arr = new int[n];
            for (int i = 0; i < arr.length; i++) {
                arr[i] = random.nextInt(left,right);
            }
            return arr;
        }

        /**
         * 生成一个大小为n的近乎有序的数组
         * @param n
         * @param times 交换的次数，次数越小越有序，次数越大越无序
         * @return
         */
        public static int[] generateSoredArray(int n,int times) {
            int[] arr = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = i;
            }
            // 交换部分元素，交换次数越小，越有序
            for (int i = 0; i < times; i++) {
                // 生成一个在[0..n]上的随机数
                int a = random.nextInt(n);
                int b = random.nextInt(n);
                int temp = arr[a];
                arr[a] = arr[b];
                arr[b] = temp;
            }
            return arr;
        }
        // 根据传入的方法名称就能调用这个方法，需要借助反射
        // 根据方法名称调用相应的排序方法对arr数组进行排序操作
        public static void testSort(String sortName,int[] arr) {
            Class<SevenSort> cls = SevenSort.class;
            try {
                Method method = cls.getDeclaredMethod(sortName,int[].class);
                long start = System.nanoTime();
                method.invoke(null,arr);
                long end = System.nanoTime();
                if (isSorted(arr)) {
                    // 算法正确
                    System.out.println(sortName + "排序结束,共耗时:" + (end - start) / 1000000.0 + "ms");
                }
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }

        // 生成一个arr的深拷贝数组
        // 为了测试不同排序算法的性能，需要在相同的数据集上进行测试
        public static int[] arrCopy(int[] arr) {
            return Arrays.copyOf(arr,arr.length);
        }

        public static boolean isSorted(int[] arr) {
            for (int i = 0; i < arr.length - 1; i++) {
                if (arr[i] > arr[i + 1]) {
                    System.err.println("sort error");
                    return false;
                }
            }
            return true;
        }
    }